

#include "Sesion.h"


Sesion::Sesion()
{

}


void Sesion::InicializarSesiones()
{
	rotacion = 0.0f;

	if(enmSesion1 == TRANSPORTAR_CUBOS)
	{
		//Materiales del Cubo
		Vector4f MatAmbCubo(1.0f, 0.1f, 0.1f, 1.0f);
		Vector4f MatDifCubo(0.0f, 1.0f, 0.0f, 1.0f);
		Vector4f MatSpcCubo(1.0f, 1.0f, 1.0f, 1.0f);
		float MatShnCubo = 50.0f;
		
	    //char *TemporalCuboPuntos = "data/VerticesCuadradoEsp4_50.txt";
		//char *TemporalCuboIndices = "data/IndicesCuadradoEsp4_50.txt";

		char *TemporalCuboPuntos = "data/ObjetoPuntos.txt";
		char *TemporalCuboIndices = "data/ObjetoIndices.txt";

		objSimulacion.setFnamePtosCubo(TemporalCuboPuntos);
		objSimulacion.setFnameIndsCubo(TemporalCuboIndices);
		objSimulacion.set_NumeroCubos(intNumeroCubos);
		objSimulacion.set_TipoSesion(TRANSPORTAR_CUBOS);

		for(int i=0;i<intNumeroCubos;i++)
		{
			fPosXCubo.push_back(0.0f);
			fPosYCubo.push_back(0.0f);
			fPosZCubo.push_back(0.0f);
			fPosXCuboAux1.push_back(0.0f);
			fPosYCuboAux1.push_back(0.0f);
			fPosZCuboAux1.push_back(0.0f);
			fPosXCuboAux2.push_back(0.0f);
			fPosYCuboAux2.push_back(0.0f);
			fPosZCuboAux2.push_back(0.0f);
		}

		objVisualizacion.set_MatAmbCubo(MatAmbCubo);
		objVisualizacion.set_MatDifCubo(MatDifCubo);
		objVisualizacion.set_MatSpcCubo(MatSpcCubo);
		objVisualizacion.set_MatShnCubo(MatShnCubo);
		objVisualizacion.set_TipoSesion(TRANSPORTAR_CUBOS);
		objVisualizacion.set_NumeroCubos(intNumeroCubos);
		
		blnVolLimiteCol = false;

		//ASIGNANDO LA POSICION AL CUBO 1
		fPosXCubo[0] = 0.0f;
		fPosYCubo[0] = 0.0f;
		fPosZCubo[0] = 0.0f;

		//ASIGNANDO LA POSICION AL CUBO 2
		fPosXCubo[1] = 100.0f;
		fPosYCubo[1] = 0.0f;
		fPosZCubo[1] = 0.0f;

		//ASIGNANDO LA POSICION AL CUBO 3
		fPosXCubo[2] = -100.0f;
		fPosYCubo[2] = 0.0f;
		fPosZCubo[2] = 0.0f;
	}
	else if(enmSesion1 == ORDENAR_CUBOS)
	{
		//Materiales del Cubo
		Vector4f MatAmbCubo(0.1f, 0.1f, 0.1f, 1.0f);
		Vector4f MatDifCubo(0.0f, 0.7f, 0.0f, 1.0f);
		Vector4f MatSpcCubo(1.0f, 1.0f, 1.0f, 1.0f);
		float MatShnCubo = 100.0f;

		char *TemporalCuboPuntos = "data/VerticesCuadradoEsp4_50.txt";
		char *TemporalCuboIndices = "data/IndicesCuadradoEsp4_50.txt";

		objSimulacion.setFnamePtosCubo(TemporalCuboPuntos);
		objSimulacion.setFnameIndsCubo(TemporalCuboIndices);
		objSimulacion.set_NumeroCubos(intNumeroCubos);
		objSimulacion.set_TipoSesion(ORDENAR_CUBOS);

		for(int i=0;i<intNumeroCubos;i++)
		{
			fPosXCubo.push_back(0.0f);
			fPosYCubo.push_back(0.0f);
			fPosZCubo.push_back(0.0f);
			fPosXCuboAux1.push_back(0.0f);
			fPosYCuboAux1.push_back(0.0f);
			fPosZCuboAux1.push_back(0.0f);
			fPosXCuboAux2.push_back(0.0f);
			fPosYCuboAux2.push_back(0.0f);
			fPosZCuboAux2.push_back(0.0f);
		}
		
		blnVolLimiteCol = false;

		//ASIGNANDO LA POSICION AL CUBO 1
		fPosXCubo[0] = 0.0f;
		fPosYCubo[0] = 0.0f;
		fPosZCubo[0] = 0.0f;

		//ASIGNANDO LA POSICION AL CUBO 2
		fPosXCubo[1] = 100.0f;
		fPosYCubo[1] = 0.0f;
		fPosZCubo[1] = 0.0f;

		//ASIGNANDO LA POSICION AL CUBO 3
		fPosXCubo[2] = -100.0f;
		fPosYCubo[2] = 0.0f;
		fPosZCubo[2] = 0.0f;

		objVisualizacion.set_TipoSesion(ORDENAR_CUBOS);
		objVisualizacion.set_NumeroCubos(intNumeroCubos);
	}
	else if(enmSesion1 == SIMULACION_HIGADO)
	{
		//Materiales del Organo
		Vector4f MatAmbOrgMain(0.4f, 0.4f, 0.4f, 1.0f);
		Vector4f MatDifOrgMain(1.0f, 0.0f, 0.0f, 1.0f);
		Vector4f MatSpcOrgMain(0.0f, 0.0f, 0.0f, 1.0f);
		float MatShnOrgMain = 128.0f;
		
		char *TemporalOrganoPuntos = "data/HigadoD50Vertices.txt";
		char *TemporalOrganoIndices = "data/HigadoD50Indices.txt";

		objSimulacion.setFnamePtosOrg(TemporalOrganoPuntos);
		objSimulacion.setFnameIndsOrg(TemporalOrganoIndices);
		objSimulacion.set_TipoSesion(SIMULACION_HIGADO);

		objVisualizacion.set_MatAmbOrgano(MatAmbOrgMain);
		objVisualizacion.set_MatDifOrgano(MatDifOrgMain);
		objVisualizacion.set_MatSpcOrgano(MatSpcOrgMain);
		objVisualizacion.set_MatShnOrgano(MatShnOrgMain);
		objVisualizacion.set_TipoSesion(SIMULACION_HIGADO);
	}
	else
	{
		throw new exception;
	}

	fValorDistanciaInicialInts1 = 0.0f;
	fValorDistanciaFinalInts1 = 0.0f;
	fDeltaDistanciaInst1 = 0.0f;
	fValorDistanciaInicialInts2 = 0.0f;
	fValorDistanciaFinalInts2 = 0.0f;
	fDeltaDistanciaInst2 = 0.0f;

	/*float LightPos[] = { 800.0f, 500.0f,-1000.0f, 1.0f};// Posicion de la iluminacion
	float LightAmb[] = { 0.5f, 0.5f, 0.5f, 1.0f};	    // Valores de la luz ambiental
	float LightDif[] = { 1.0f, 1.0f, 1.0f, 1.0f};	    // Valores de la luz difusa
	float LightSpc[] = {-0.2f, -0.2f, -0.2f, 1.0f};	    // Valores de la luz especular
	float LightShn[] = {1.0f, 1.0f, 1.0f, 1.0f, 1.0f};*/

	float LightPos1[] = {10.0f, 0.0f, -590.0f, 1.0f};// Posicion de la iluminacion
	float LightAmb1[] = { 0.2f, 0.2f, 0.2f, 1.0f};	    // Valores de la luz ambiental
	float LightDif1[] = { 0.5f, 0.5f, 0.5f, 1.0f};	    // Valores de la luz difusa
	float LightSpc1[] = {1.0f, 1.0f, 1.0f, 1.0f};	    // Valores de la luz especular
	float LightShn1[] = {1.0f, 1.0f, 1.0f, 1.0f, 1.0f};

	float LightPos2[] = {10.0f, 0.0f, -590.0f, 1.0f};// Posicion de la iluminacion
	float LightAmb2[] = { 0.2f, 0.2f, 0.2f, 1.0f};	    // Valores de la luz ambiental
	float LightDif2[] = { 0.5f, 0.5f, 0.5f, 1.0f};	    // Valores de la luz difusa
	float LightSpc2[] = {1.0f, 1.0f, 1.0f, 1.0f};	    // Valores de la luz especular
	float LightShn2[] = {1.0f, 1.0f, 1.0f, 1.0f, 1.0f};

	/*LightPos[0] = 0.0f;
	LightPos[1] = -710.0f;
	LightPos[2] = 0.0f;
	LightPos[3] = 1.0f;*/
	
	//float LightAmb[] = { 0.2f, 0.2f, 0.2f, 1.0f};			// Ambient Light Values
	//float LightDif[] = { 0.6f, 0.6f, 0.6f, 1.0f};			// Diffuse Light Values
	//float LightSpc[] = {-0.2f, -0.2f, -0.2f, 1.0f};			// Specular Light Values

	//Materiales del Instrumento 1
	Vector4f MatAmbInst1Main(0.4f, 0.4f, 0.4f, 1.0f);
	Vector4f MatDifInst1Main(0.0f, 1.0f, 0.0f, 1.0f);
	Vector4f MatSpcInst1Main(1.0f, 1.0f, 1.0f, 1.0f);
	float MatShnInst1Main = 100.0f;

	//Materiales del instrumento 2
	Vector4f MatAmbInst2Main(0.4f, 0.4f, 0.4f, 1.0f);
	Vector4f MatDifInst2Main(0.0f, 0.0f, 1.0f, 1.0f);
	Vector4f MatSpcInst2Main(1.0f, 1.0f, 1.0f, 1.0f);
	float MatShnInst2Main = 100.0f;

	glShadeModel(GL_SMOOTH);							
	glClearColor(0.0f, 0.0f, 0.0f, 0.5f);				
	glClearDepth(1.0f);									
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);								
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

	glLightfv(GL_LIGHT1, GL_POSITION, LightPos1);		// Configura la posicion de la luz
	glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmb1);			// Configura la luz ambiental
	glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDif1);			// Configura la luz difusa
	glLightfv(GL_LIGHT1, GL_SPECULAR, LightSpc1);		// configura la luz especular
	glLightfv(GL_LIGHT1, GL_SHININESS, LightShn1);

	glLightfv(GL_LIGHT2, GL_POSITION, LightPos2);		// Configura la posicion de la luz
	glLightfv(GL_LIGHT2, GL_AMBIENT, LightAmb2);			// Configura la luz ambiental
	glLightfv(GL_LIGHT2, GL_DIFFUSE, LightDif2);			// Configura la luz difusa
	glLightfv(GL_LIGHT2, GL_SPECULAR, LightSpc2);		// configura la luz especular
	glLightfv(GL_LIGHT1, GL_SHININESS, LightShn2);

	glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, 1.2f);
    glLightf(GL_LIGHT1, GL_SPOT_EXPONENT, 20.0f);

	glEnable(GL_LIGHT1);								// Enable Light1
	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT2);
	glEnable(GL_LIGHTING);

	glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);    //Permite iluminacion por ambas caras

	//Para eliminar las caras posteriores
	glCullFace(GL_BACK);			// Configura Culling Face a la cara de atras
	glEnable(GL_CULL_FACE);			// Habilita el Culling

	char **TemporalInstrumentoPuntos;
	char **TemporalInstrumentoIndices;

	TemporalInstrumentoPuntos = new char*[9];
	TemporalInstrumentoIndices = new char*[9];

	TemporalInstrumentoPuntos[0] = "data/ArchivoPuntosPinzaLaparoscopicaMalla1.txt";
	TemporalInstrumentoIndices[0] = "data/IndicesPinzaLaparoscopicaMalla1.txt";
	TemporalInstrumentoPuntos[1] = "data/ArchivoPuntosPinzaLaparoscopicaMalla2.txt";
	TemporalInstrumentoIndices[1] = "data/IndicesPinzaLaparoscopicaMalla2.txt";
	TemporalInstrumentoPuntos[2] = "data/ArchivoPuntosPinzaLaparoscopicaMalla3.txt";
	TemporalInstrumentoIndices[2] = "data/IndicesPinzaLaparoscopicaMalla3.txt";
	TemporalInstrumentoPuntos[3] = "data/ArchivoPuntosPinzaLaparoscopicaMalla4.txt";
	TemporalInstrumentoIndices[3] = "data/IndicesPinzaLaparoscopicaMalla4.txt";
	TemporalInstrumentoPuntos[4] = "data/ArchivoPuntosPinzaLaparoscopicaMalla5.txt";
	TemporalInstrumentoIndices[4] = "data/IndicesPinzaLaparoscopicaMalla5.txt";
	TemporalInstrumentoPuntos[5] = "data/ArchivoPuntosPinzaLaparoscopicaMalla6.txt";
	TemporalInstrumentoIndices[5] = "data/IndicesPinzaLaparoscopicaMalla6.txt";
	TemporalInstrumentoPuntos[6] = "data/ArchivoPuntosPinzaLaparoscopicaMalla7.txt";
	TemporalInstrumentoIndices[6] = "data/IndicesPinzaLaparoscopicaMalla7.txt";
	TemporalInstrumentoPuntos[7] = "data/ArchivoPuntosPinzaLaparoscopicaMalla8.txt";
	TemporalInstrumentoIndices[7] = "data/IndicesPinzaLaparoscopicaMalla8.txt";
	TemporalInstrumentoPuntos[8] = "data/ArchivoPuntosPinzaLaparoscopicaMalla9.txt";
	TemporalInstrumentoIndices[8] = "data/IndicesPinzaLaparoscopicaMalla9.txt";

	objSimulacion.setFnamePtosInst1(TemporalInstrumentoPuntos);
	objSimulacion.setFnameIndsInst1(TemporalInstrumentoIndices);
	objSimulacion.setNroMallasInst1(9);

	objSimulacion.setFnamePtosInst2(TemporalInstrumentoPuntos);
	objSimulacion.setFnameIndsInst2(TemporalInstrumentoIndices);
	objSimulacion.setNroMallasInst2(9);
	objSimulacion.setTimeStep(20.0);

	objSimulacion.IncializarSimulacion();

	objVisualizacion.set_Simulacion(objSimulacion);
	objVisualizacion.set_TipoVisualizacion(DIBUJAR_CONTORNO_SMOOTH);
	objVisualizacion.set_NumeroMallasInst1(9);
	objVisualizacion.set_NumeroMallasInst2(9);

	objVisualizacion.set_MatAmbInst1(MatAmbInst1Main);
	objVisualizacion.set_MatDifInst1(MatDifInst1Main);
	objVisualizacion.set_MatSpcInst1(MatSpcInst1Main);
	objVisualizacion.set_MatShnInst1(MatShnInst1Main);

	objVisualizacion.set_MatAmbInst2(MatAmbInst2Main);
	objVisualizacion.set_MatDifInst2(MatDifInst2Main);
	objVisualizacion.set_MatSpcInst2(MatSpcInst2Main);
	objVisualizacion.set_MatShnInst2(MatShnInst2Main);

	objVisualizacion.Incializar();

	if(enmSesion1 == TRANSPORTAR_CUBOS || enmSesion1 == ORDENAR_CUBOS)
	{
		//ASIGNANDO TRIANGULO 1 CUBO 

		//Vertice 1
		/*objTrianguloTempCubo1.getVertice1()->setX(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(82).getVertice1()->getX());
		objTrianguloTempCubo1.getVertice1()->setY(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(82).getVertice1()->getY());
		objTrianguloTempCubo1.getVertice1()->setZ(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(82).getVertice1()->getZ());

		//Vertice 2
		objTrianguloTempCubo1.getVertice2()->setX(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(82).getVertice2()->getX());
		objTrianguloTempCubo1.getVertice2()->setY(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(82).getVertice2()->getY());
		objTrianguloTempCubo1.getVertice2()->setZ(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(82).getVertice2()->getZ());

		//Vertice3
		objTrianguloTempCubo1.getVertice3()->setX(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(82).getVertice3()->getX());
		objTrianguloTempCubo1.getVertice3()->setY(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(82).getVertice3()->getY());
		objTrianguloTempCubo1.getVertice3()->setZ(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(82).getVertice3()->getZ());

		//ASIGNANDO TRIANGULO 2 CUBO 

		//Vertice 1
		objTrianguloTempCubo2.getVertice1()->setX(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(397).getVertice1()->getX());
		objTrianguloTempCubo2.getVertice1()->setY(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(397).getVertice1()->getY());
		objTrianguloTempCubo2.getVertice1()->setZ(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(397).getVertice1()->getZ());

		//Vertice 2
		objTrianguloTempCubo2.getVertice2()->setX(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(397).getVertice2()->getX());
		objTrianguloTempCubo2.getVertice2()->setY(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(397).getVertice2()->getY());
		objTrianguloTempCubo2.getVertice2()->setZ(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(397).getVertice2()->getZ());

		//Vertice3
		objTrianguloTempCubo2.getVertice3()->setX(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(397).getVertice3()->getX());
		objTrianguloTempCubo2.getVertice3()->setY(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(397).getVertice3()->getY());
		objTrianguloTempCubo2.getVertice3()->setZ(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(397).getVertice3()->getZ());*/

		//ASIGNANDO TRIANGULO 1 CUBO 

		//Vertice 1
		objTrianguloTempCubo1.getVertice1()->setX(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(0).getVertice1()->getX());
		objTrianguloTempCubo1.getVertice1()->setY(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(0).getVertice1()->getY());
		objTrianguloTempCubo1.getVertice1()->setZ(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(0).getVertice1()->getZ());

		//Vertice 2
		objTrianguloTempCubo1.getVertice2()->setX(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(0).getVertice2()->getX());
		objTrianguloTempCubo1.getVertice2()->setY(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(0).getVertice2()->getY());
		objTrianguloTempCubo1.getVertice2()->setZ(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(0).getVertice2()->getZ());

		//Vertice3
		objTrianguloTempCubo1.getVertice3()->setX(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(0).getVertice3()->getX());
		objTrianguloTempCubo1.getVertice3()->setY(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(0).getVertice3()->getY());
		objTrianguloTempCubo1.getVertice3()->setZ(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(0).getVertice3()->getZ());

		//ASIGNANDO TRIANGULO 2 CUBO 

		//Vertice 1
		objTrianguloTempCubo2.getVertice1()->setX(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(10).getVertice1()->getX());
		objTrianguloTempCubo2.getVertice1()->setY(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(10).getVertice1()->getY());
		objTrianguloTempCubo2.getVertice1()->setZ(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(10).getVertice1()->getZ());

		//Vertice 2
		objTrianguloTempCubo2.getVertice2()->setX(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(10).getVertice2()->getX());
		objTrianguloTempCubo2.getVertice2()->setY(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(10).getVertice2()->getY());
		objTrianguloTempCubo2.getVertice2()->setZ(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(10).getVertice2()->getZ());

		//Vertice3
		objTrianguloTempCubo2.getVertice3()->setX(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(10).getVertice3()->getX());
		objTrianguloTempCubo2.getVertice3()->setY(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(10).getVertice3()->getY());
		objTrianguloTempCubo2.getVertice3()->setZ(objSimulacion.getOneCubo(0).getSupTriang().get_Triangulo(10).getVertice3()->getZ());
	}

	if(enmSesion1 == ORDENAR_CUBOS)
	{
		//Materiales del Cubo 1
		Vector4f MatAmbCubo1(0.0f, 0.0f, 1.0f, 1.0f);
		Vector4f MatDifCubo1(1.0f, 0.0f, 0.0f, 1.0f);
		Vector4f MatSpcCubo1(0.0f, 0.0f, 0.0f, 1.0f);
		float MatShnCubo1 = 128.0f;

		vMatAmbCubo.push_back(MatAmbCubo1);
		vMatDifCubo.push_back(MatDifCubo1);
		vMatSpcCubo.push_back(MatSpcCubo1);
		vMatShnCubo.push_back(MatShnCubo1);

		//Materiales del Cubo 2
		Vector4f MatAmbCubo2(0.5f, 0.25f, 0.25f, 1.0f);
		Vector4f MatDifCubo2(0.5f, 0.25f, 0.25f, 1.0f);
		Vector4f MatSpcCubo2(0.5f, 0.25f, 0.25f, 1.0f);
		float MatShnCubo2 = 128.0f;

		vMatAmbCubo.push_back(MatAmbCubo2);
		vMatDifCubo.push_back(MatDifCubo2);
		vMatSpcCubo.push_back(MatSpcCubo2);
		vMatShnCubo.push_back(MatShnCubo2);

		//Materiales del Cubo 3
		Vector4f MatAmbCubo3(0.0f, 0.25f, .0f, 1.0f);
		Vector4f MatDifCubo3(0.0f, 0.25f, 0.0f, 1.0f);
		Vector4f MatSpcCubo3(0.0f, 0.25f, 0.0f, 1.0f);
		float MatShnCubo3 = 128.0f;

		vMatAmbCubo.push_back(MatAmbCubo3);
		vMatDifCubo.push_back(MatDifCubo3);
		vMatSpcCubo.push_back(MatSpcCubo3);
		vMatShnCubo.push_back(MatShnCubo3);

		//Material 1
		objVisualizacion.set_vMatAmbCubo(MatAmbCubo1,0);
		objVisualizacion.set_vMatDifCubo(MatDifCubo1,0);
		objVisualizacion.set_vMatSpcCubo(MatSpcCubo1,0);
		objVisualizacion.set_vMatShnCubo(MatShnCubo1,0);
		//Material 2
		objVisualizacion.set_vMatAmbCubo(MatAmbCubo2,1);
		objVisualizacion.set_vMatDifCubo(MatDifCubo2,1);
		objVisualizacion.set_vMatSpcCubo(MatSpcCubo2,1);
		objVisualizacion.set_vMatShnCubo(MatShnCubo2,1);
		//Material 3
		objVisualizacion.set_vMatAmbCubo(MatAmbCubo3,2);
		objVisualizacion.set_vMatDifCubo(MatDifCubo3,2);
		objVisualizacion.set_vMatSpcCubo(MatSpcCubo3,2);
		objVisualizacion.set_vMatShnCubo(MatShnCubo3,2);
	}

	//ASIGNANDO TRIANGULO DE COLISION DEL INSTRUMENTO 1

	//Solucionando el vertice 1
	objTrianguloTemp1.getVertice1()->setX(objSimulacion.getInstrumentoQco1().getOneSupTriang(6).get_Triangulo(5).getVertice1()->getX());
	objTrianguloTemp1.getVertice1()->setY(objSimulacion.getInstrumentoQco1().getOneSupTriang(6).get_Triangulo(5).getVertice1()->getY());
	objTrianguloTemp1.getVertice1()->setZ(objSimulacion.getInstrumentoQco1().getOneSupTriang(6).get_Triangulo(5).getVertice1()->getZ());

	//Solucionando el vertice 2
	objTrianguloTemp1.getVertice2()->setX(objSimulacion.getInstrumentoQco1().getOneSupTriang(6).get_Triangulo(5).getVertice2()->getX());
	objTrianguloTemp1.getVertice2()->setY(objSimulacion.getInstrumentoQco1().getOneSupTriang(6).get_Triangulo(5).getVertice2()->getY());
	objTrianguloTemp1.getVertice2()->setZ(objSimulacion.getInstrumentoQco1().getOneSupTriang(6).get_Triangulo(5).getVertice2()->getZ());

	//Solucionando el vertice 2
	objTrianguloTemp1.getVertice3()->setX(objSimulacion.getInstrumentoQco1().getOneSupTriang(6).get_Triangulo(5).getVertice3()->getX());
	objTrianguloTemp1.getVertice3()->setY(objSimulacion.getInstrumentoQco1().getOneSupTriang(6).get_Triangulo(5).getVertice3()->getY());
	objTrianguloTemp1.getVertice3()->setZ(objSimulacion.getInstrumentoQco1().getOneSupTriang(6).get_Triangulo(5).getVertice3()->getZ());

	//ASIGNANDO TRIANGULO DE COLISION DEL INSTRUMENTO 2

	//Solucionando el vertice 1
	objTrianguloTemp2.getVertice1()->setX(objSimulacion.getInstrumentoQco2().getOneSupTriang(6).get_Triangulo(5).getVertice1()->getX());
	objTrianguloTemp2.getVertice1()->setY(objSimulacion.getInstrumentoQco2().getOneSupTriang(6).get_Triangulo(5).getVertice1()->getY());
	objTrianguloTemp2.getVertice1()->setZ(objSimulacion.getInstrumentoQco2().getOneSupTriang(6).get_Triangulo(5).getVertice1()->getZ());

	//Solucionando el vertice 2
	objTrianguloTemp2.getVertice2()->setX(objSimulacion.getInstrumentoQco2().getOneSupTriang(6).get_Triangulo(5).getVertice2()->getX());
	objTrianguloTemp2.getVertice2()->setY(objSimulacion.getInstrumentoQco2().getOneSupTriang(6).get_Triangulo(5).getVertice2()->getY());
	objTrianguloTemp2.getVertice2()->setZ(objSimulacion.getInstrumentoQco2().getOneSupTriang(6).get_Triangulo(5).getVertice2()->getZ());

	//Solucionando el vertice 2
	objTrianguloTemp2.getVertice3()->setX(objSimulacion.getInstrumentoQco2().getOneSupTriang(6).get_Triangulo(5).getVertice3()->getX());
	objTrianguloTemp2.getVertice3()->setY(objSimulacion.getInstrumentoQco2().getOneSupTriang(6).get_Triangulo(5).getVertice3()->getY());
	objTrianguloTemp2.getVertice3()->setZ(objSimulacion.getInstrumentoQco2().getOneSupTriang(6).get_Triangulo(5).getVertice3()->getZ());

	blnSensadoPolhemus = false;
}

void Sesion::DibujarSesion()
{
	GLfloat m[16];
	GLfloat pos[4];

	GLfloat Minv[16];
	GLfloat wlp[4];
	GLfloat lp[4];

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	if(enmSesion1 == TRANSPORTAR_CUBOS || enmSesion1 == ORDENAR_CUBOS)
	{
		DrawGround();

		//Aplicando Sombras a los cubos
		glLoadIdentity();

		/*glTranslatef(xtrasl, ytrasl, -790.0f+ztrasl);
		glRotatef(xrot+102.0f, 1.0f, 0.0f, 0.0f);
		glRotatef(yrot, 0.0f, 1.0f, 0.0f);
		glRotatef(zrot, 0.0f, 0.0f, 1.0f);*/

		//glLightfv(GL_LIGHT1, GL_POSITION, LightPos);
		cout << LightPos[0] << "  " << LightPos[1] << "  " << LightPos[2] << endl;
		glTranslatef(LightPos[0],LightPos[1], LightPos[2]);

		float MatAmbGround[4] = {0.1f,0.1f,0.1f,1.0f};
		float MatDifGround[4] = {1.0f,0.0f,0.0f,1.0f};
		float MatSpcGround[4] = {1.0f,1.0f,1.0f,1.0f};
		float MatShnGround = 100.0f;

		glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, MatAmbGround);			// Configura material ambiental
		glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MatDifGround);			// Configura material difuso
		glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, MatSpcGround);		// Configura material especular
		glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, MatShnGround);

		//glColor3f(1.0f, 0.5f, 0.0f);
		glutSolidSphere(10.0f,15,15);

		//Asignando el punto de origen a la inversa
		/*glRotatef(-zrot, 0.0f, 0.0f, 1.0f);
		glRotatef(-yrot, 0.0f, 1.0f, 0.0f);
		glRotatef(-(xrot+102.0f), 1.0f, 0.0f, 0.0f);
		glTranslatef(-xtrasl, -ytrasl, -(-790.0f+ztrasl));
		glGetFloatv(GL_MODELVIEW_MATRIX,Minv);
		lp[0] = LightPos[0];
		lp[1] = LightPos[1];
		lp[2] = LightPos[2];
		lp[3] = LightPos[3];
		VMatMult(Minv, lp);
		glTranslatef(-objSimulacion.getOneCubo(0).get_PosX(),-objSimulacion.getOneCubo(0).get_PosY(),
			-objSimulacion.getOneCubo(0).get_PosZ());
		wlp[0] = 0.0f;
		wlp[1] = 0.0f;
		wlp[2] = 0.0f;
		wlp[3] = 1.0f;
		VMatMult(Minv,wlp);

		lp[0] += wlp[0];
		lp[1] += wlp[1];
		lp[2] += wlp[2];*/

		//cout << LightPos[0] << "  " << LightPos[1] << "  " << LightPos[2] << endl;

		glLoadIdentity();									
		//glColor3f(1.0f, 0.0f, 0.0f);

		rotacion += 5.0f;   //	TEMPORAL

		for(int i=0;i<intNumeroCubos;i++)
		{
			//Propiedades de Ubicacion para la visualizacion del Cubo
			objSimulacion.getOneCubo(i).set_RotX(rotacion);
			objSimulacion.getOneCubo(i).set_RotY(0.0f);
			objSimulacion.getOneCubo(i).set_RotZ(0.0f);
		}

		objVisualizacion.set_Simulacion(objSimulacion);

		//Asignando el punto de origen
		glTranslatef(xtrasl, ytrasl, -790.0f+ztrasl);
		glRotatef(xrot+102.0f, 1.0f, 0.0f, 0.0f);
		glRotatef(yrot, 0.0f, 1.0f, 0.0f);
		glRotatef(zrot, 0.0f, 0.0f, 1.0f);

		for(int i=0;i<intNumeroCubos;i++)
		{
			glPushMatrix();

			objVisualizacion.DisplayCubo(i);

			if(i==0)
			{
				/*objVisualizacion.CastShadow(0,lp);

				glTranslatef(lp[0],lp[1],lp[2]);

				glPointSize(20.0f);
				glBegin(GL_POINTS);
				glVertex3f(0.0f,0.0f,0.0f);
				glEnd();*/
			}

			glPopMatrix();
		}

		//Propiedades de Ubicacion para la visualizacion del Instrumento 1
		objVisualizacion.set_PosInstrumento1X(150.0f);
		//objVisualizacion.set_PosInstrumento1Y(0.0f);
		objVisualizacion.set_PosInstrumento1Z(0.0f);

		objVisualizacion.set_RotInstrumento1X(-ryPolInts1);
		objVisualizacion.set_RotInstrumento1Y(rzPolInts1);		
		objVisualizacion.set_RotInstrumento1Z(rxPolInts1);

		objVisualizacion.set_PosInstrumento1Y(fDeltaDistanciaInst1);

		//Propiedades de Ubicacion para la visualizacion del Instrumento 2
		objVisualizacion.set_PosInstrumento2X(-150.0f);
		//objVisualizacion.set_PosInstrumento2Y(0.0f);
		objVisualizacion.set_PosInstrumento2Z(0.0f);

		objVisualizacion.set_RotInstrumento2X(-ryPolInts2);
		objVisualizacion.set_RotInstrumento2Y(rzPolInts2);		
		objVisualizacion.set_RotInstrumento2Z(rxPolInts2);

		objVisualizacion.set_PosInstrumento2Y(fDeltaDistanciaInst2);

		VisualizandoInstrumentos(0.0f, 0.0f, -790.0f, 150.0f, 250.0f, 0.0f, -150.0f, 
			250.0f, 0.0f);

		for(int i=0;i<intNumeroCubos;i++)
		{
			//Para el instrumento 1
			glLoadIdentity();

			glTranslatef(xtrasl, ytrasl, -790.0f+ztrasl);
			glRotatef(xrot+102.0f, 1.0f, 0.0f, 0.0f);
			glRotatef(yrot, 0.0f, 1.0f, 0.0f);
			glRotatef(zrot, 0.0f, 0.0f, 1.0f);

			//Aplica las traslaciones
			glTranslatef(fPosXCubo[i], fPosYCubo[i], fPosZCubo[i]);

			glGetFloatv(GL_MODELVIEW_MATRIX, m);

			//Coordenada 1
			pos[0] = objTrianguloTempCubo1.getVertice1()->getX();
			pos[1] = objTrianguloTempCubo1.getVertice1()->getY();
			pos[2] = objTrianguloTempCubo1.getVertice1()->getZ();
			pos[3] = 1.0f;
			VMatMult(m,pos);
			objSimulacion.getOneTrianguloTempCubo1(i).getVertice1()->setX(pos[0]);
			objSimulacion.getOneTrianguloTempCubo1(i).getVertice1()->setY(pos[1]);
			objSimulacion.getOneTrianguloTempCubo1(i).getVertice1()->setZ(pos[2]);


			//Para el instrumento 2
			glLoadIdentity();

			glTranslatef(xtrasl, ytrasl, -790.0f+ztrasl);
			glRotatef(xrot+102.0f, 1.0f, 0.0f, 0.0f);
			glRotatef(yrot, 0.0f, 1.0f, 0.0f);
			glRotatef(zrot, 0.0f, 0.0f, 1.0f);

			//Aplica las traslaciones
			glTranslatef(fPosXCubo[i], fPosYCubo[i], fPosZCubo[i]);

			glGetFloatv(GL_MODELVIEW_MATRIX, m);

			//Coordenada 1
			pos[0] = objTrianguloTempCubo2.getVertice1()->getX();
			pos[1] = objTrianguloTempCubo2.getVertice1()->getY();
			pos[2] = objTrianguloTempCubo2.getVertice1()->getZ();
			pos[3] = 1.0f;
			VMatMult(m,pos);
			objSimulacion.getOneTrianguloTempCubo2(i).getVertice1()->setX(pos[0]);
			objSimulacion.getOneTrianguloTempCubo2(i).getVertice1()->setY(pos[1]);
			objSimulacion.getOneTrianguloTempCubo2(i).getVertice1()->setZ(pos[2]);
		

			if(blnVolLimiteCol == true)
			{
				glLoadIdentity();

				//Dibujando Esfera Cubo
				glTranslatef(objSimulacion.getOneCubo(i).get_Esfera().get_Centro().getX(),
					objSimulacion.getOneCubo(i).get_Esfera().get_Centro().getY(),
					objSimulacion.getOneCubo(i).get_Esfera().get_Centro().getZ());

				glutWireSphere(objSimulacion.getOneCubo(i).get_Esfera().get_Radio(),15,15);
			}
		}
	}
	else if(enmSesion1 == SIMULACION_HIGADO)
	{
		glLoadIdentity();									
		glColor3f(1.0f, 0.0f, 0.0f);

		//Propiedades de Ubicacion para la visualizacion del organo
		objVisualizacion.set_PosOrganoX(0.0f);
		objVisualizacion.set_PosOrganoY(0.0f);
		objVisualizacion.set_PosOrganoZ(0.0f);

		objVisualizacion.set_RotOrganoX(0.0f);
		objVisualizacion.set_RotOrganoY(0.0f);		
		objVisualizacion.set_RotOrganoZ(0.0f);

		//Asignando el punto de origen
		glTranslatef(-170.0f+xtrasl, 90.0f+ytrasl, -930.0f+ztrasl);
		glRotatef(xrot+102.0f, 1.0f, 0.0f, 0.0f);
		glRotatef(yrot, 0.0f, 1.0f, 0.0f);
		glRotatef(zrot, 0.0f, 0.0f, 1.0f);

		glPushMatrix();

		objVisualizacion.DisplayOrgano();

		glPopMatrix();

		//Propiedades de Ubicacion para la visualizacion del Instrumento 1
		objVisualizacion.set_PosInstrumento1X(400.0f);
		//objVisualizacion.set_PosInstrumento1Y(250.0f);
		objVisualizacion.set_PosInstrumento1Z(-50.0f);

		objVisualizacion.set_RotInstrumento1X(-ryPolInts1);
		objVisualizacion.set_RotInstrumento1Y(rzPolInts1);		
		objVisualizacion.set_RotInstrumento1Z(rxPolInts1);

		objVisualizacion.set_PosInstrumento1Y(fDeltaDistanciaInst1);

		//Propiedades de Ubicacion para la visualizacion del Instrumento 2
		objVisualizacion.set_PosInstrumento2X(0.0f);
		//objVisualizacion.set_PosInstrumento2Y(250.0f);
		objVisualizacion.set_PosInstrumento2Z(-50.0f);

		objVisualizacion.set_RotInstrumento2X(-ryPolInts2);
		objVisualizacion.set_RotInstrumento2Y(rzPolInts2);		
		objVisualizacion.set_RotInstrumento2Z(rxPolInts2);

		objVisualizacion.set_PosInstrumento2Y(fDeltaDistanciaInst2);

		VisualizandoInstrumentos(-170.0f, 90.0f, -930.0f, 400.0f, 250.0f, -50.0f, 0.0f, 
			250.0f, -50.0f);

		/*frame++;
		timet=glutGet(GLUT_ELAPSED_TIME);
		if (timet - timebase > 1000) {
		sprintf(s,"FPS:%4.2f",frame*1000.0/(timet-timebase));
		timebase = timet;		
		frame = 0;
		}
		cout << s << endl;*/
	}
	else
	{
		throw new exception;
	}
}

void Sesion::ActualizarSesion()
{
	xPolInst1 = 0.0;
	yPolInst1 = 0.0;
	zPolInst1 = 0.0;

	rxPolInts1 = 0.0;
	ryPolInts1 = 0.0;
	rzPolInts1 = 0.0;

	objSimulacion.ActualizarInstrumentos();
	objSimulacion.Simular();

	if(enmSesion1 == TRANSPORTAR_CUBOS || enmSesion1 == ORDENAR_CUBOS)
	{
		if(objSimulacion.getHayColisionInst1())
		{
			if(intGInst1 < 210)
			{
				for(int i=0;i<intNumeroCubos;i++)
				{
					if(objSimulacion.get_IDCuboInst1() == i)
					{
						fPosXCubo[i] = fPosXCuboAux1[i];
						fPosYCubo[i] = fPosYCuboAux1[i];
						fPosZCubo[i] = fPosZCuboAux1[i];
						objSimulacion.getOneCubo(i).set_PosX(fPosXCuboAux1[i]);
						objSimulacion.getOneCubo(i).set_PosY(fPosYCuboAux1[i]);
						objSimulacion.getOneCubo(i).set_PosZ(fPosZCuboAux1[i]);
					}
				}
			}
		}

		if(objSimulacion.getHayColisionInst2())
		{
			if(intGInst2 < 235)
			{
				for(int i=0;i<intNumeroCubos;i++)
				{
					if(objSimulacion.get_IDCuboInst2() == i)
					{
						fPosXCubo[i] = fPosXCuboAux2[i];
						fPosYCubo[i] = fPosYCuboAux2[i];
						fPosZCubo[i] = fPosZCuboAux2[i];
						objSimulacion.getOneCubo(i).set_PosX(fPosXCuboAux2[i]);
						objSimulacion.getOneCubo(i).set_PosY(fPosYCuboAux2[i]);
						objSimulacion.getOneCubo(i).set_PosZ(fPosZCuboAux2[i]);
					}
				}
			}
		}

		objSimulacion.setHayColisionInst1(false);
		objSimulacion.setHayColisionInst2(false);
	}
	/*else if(enmSesion1 == ORDENAR_CUBOS)
	{
	
	}*/
	else if(enmSesion1 == SIMULACION_HIGADO)
	{
		objVisualizacion.set_IDTriangColisionado1(objSimulacion.getIDTriangColOrg1());
		objVisualizacion.set_IDTriangColisionado2(objSimulacion.getIDTriangColOrg2());
	}
	else
	{
		throw new exception;
	}

	xPolInst1 = objSimulacion.getInstrumentoQco1().get_CoordenadaX();
	yPolInst1 = objSimulacion.getInstrumentoQco1().get_CoordenadaY();
	zPolInst1 = objSimulacion.getInstrumentoQco1().get_CoordenadaZ();

	rxPolInts1 = objSimulacion.getInstrumentoQco1().get_RotacionX();
	ryPolInts1 = objSimulacion.getInstrumentoQco1().get_RotacionY();
	rzPolInts1 = objSimulacion.getInstrumentoQco1().get_RotacionZ();

	xPolInst2 = objSimulacion.getInstrumentoQco2().get_CoordenadaX();
	yPolInst2 = objSimulacion.getInstrumentoQco2().get_CoordenadaY();
	zPolInst2 = objSimulacion.getInstrumentoQco2().get_CoordenadaZ();

	rxPolInts2 = objSimulacion.getInstrumentoQco2().get_RotacionX();
	ryPolInts2 = objSimulacion.getInstrumentoQco2().get_RotacionY();
	rzPolInts2 = objSimulacion.getInstrumentoQco2().get_RotacionZ();

	if(blnSensadoPolhemus==false)
	{
		//Para el instrumento 1
		float fValorInicialXInst1, fValorInicialYInst1, fValorInicialZInst1; 
		
		fValorInicialXInst1 = xPolInst1;
		fValorInicialYInst1 = yPolInst1;
		fValorInicialZInst1 = zPolInst1;

		fValorDistanciaInicialInts1 = sqrt(pow(fValorInicialXInst1-(-2.55),2)+pow(fValorInicialYInst1-(17.43),2)+
			pow(fValorInicialZInst1-(22.90),2));

		//Para el instrumento 2
		float fValorInicialXInst2, fValorInicialYInst2, fValorInicialZInst2;

		fValorInicialXInst2 = xPolInst2;
		fValorInicialYInst2 = yPolInst2;
		fValorInicialZInst2 = zPolInst2;

		fValorDistanciaInicialInts2 = sqrt(pow(fValorInicialXInst2-(-1.35),2)+pow(fValorInicialYInst2-(-9.57),2)+
			pow(fValorInicialZInst2-(27.43),2));

		blnSensadoPolhemus = true;
	}
	else
	{
		//Para el instrumento 1
		fValorDistanciaFinalInts1 = sqrt(pow(xPolInst1-(-2.55),2)+pow(yPolInst1-(17.43),2)+
			pow(zPolInst1-(22.90),2));

		fDeltaDistanciaInst1 = (fValorDistanciaInicialInts1-fValorDistanciaFinalInts1)*5.0f;

		//Para el instrumento 2
		fValorDistanciaFinalInts2 = sqrt(pow(xPolInst2-(-1.35),2)+pow(yPolInst2-(-9.57),2)+
			pow(zPolInst2-(27.43),2));

		fDeltaDistanciaInst2 = (fValorDistanciaInicialInts2-fValorDistanciaFinalInts2)*5.0f;
	}

	intGInst1 = objSimulacion.getInstrumentoQco1().get_GradosPuntaInstrumento();
	intGInst2 = objSimulacion.getInstrumentoQco2().get_GradosPuntaInstrumento();
}

void Sesion::VMatMult(GLfloat *M, GLfloat *v) {
	GLfloat res[4];

	res[0]=M[ 0]*v[0]+M[ 4]*v[1]+M[ 8]*v[2]+M[12]*v[3];
	res[1]=M[ 1]*v[0]+M[ 5]*v[1]+M[ 9]*v[2]+M[13]*v[3];
	res[2]=M[ 2]*v[0]+M[ 6]*v[1]+M[10]*v[2]+M[14]*v[3];
	res[3] = M[15];
	v[0]=res[0];
	v[1]=res[1];
	v[2]=res[2];
	v[3]=M[15];											
}

void Sesion::VisualizandoInstrumentos(float fMainX, float fMainY, float fMainZ, float fX1,
									  float fY1, float fZ1, float fX2, float fY2, float fZ2)
{
	//VISUALIZANDO EL INSTRUMENTO 1 LOS INSTRUMENTOS

	glColor3f(0.0f, 1.0f, 0.0f);

	glPushMatrix();

	objVisualizacion.DisplayInst1();

	glPopMatrix();

	//VISUALIZANDO EL INSTRUMENTO 2

	glColor3f(0.0f, 0.0f, 1.0f);

	glPushMatrix();

	objVisualizacion.DisplayInst2();

	glPopMatrix();

	//Triangulo de colision del instrumento
	TransVisTriangCol( fMainX, fMainY, fMainZ, fX1, fY1, fZ1, fX2, fY2, fZ2);

	//Esferas que rodean el triangulo de colision del instrumento
	if(blnVolLimiteCol == true)
	{
		DrawSphereTriang( fMainX, fMainY, fMainZ, fX1, fY1, fZ1, fX2, fY2, fZ2);
	}

	//Tranformacion auxiliar para le desplazamiento del cubo
	AuxTriangCubo( fMainX, fMainY, fMainZ, fX1, fY1, fZ1, fX2, fY2, fZ2);
}

void Sesion::TransVisTriangCol(float fMainX, float fMainY, float fMainZ, float fX1,
								float fY1, float fZ1, float fX2, float fY2, float fZ2)
{
	GLfloat m[16];
	GLfloat pos[4];

	//TRANSFORMANDO EL TRIANGULO DE COLISION DEL INSTRUMENTO 1
	glLoadIdentity();

	if(enmSesion1 == TRANSPORTAR_CUBOS || enmSesion1 == ORDENAR_CUBOS)
	{
		glTranslatef(fMainX+xtrasl, fMainY+ytrasl, fMainZ+ztrasl);
		glRotatef(xrot+102.0f, 1.0f, 0.0f, 0.0f);
		glRotatef(yrot, 0.0f, 1.0f, 0.0f);
		glRotatef(zrot, 0.0f, 0.0f, 1.0f);
	}

	//Aplica las traslaciones	
	glTranslatef(fX1, fY1, fZ1);		//400.0	  250.0   -50.0

	//Aplica las rotaciones
	glRotatef(-ryPolInts1, 1.0f, 0.0f, 0.0f);
	glRotatef(rzPolInts1, 0.0f, 1.0f, 0.0f);
	glRotatef(rxPolInts1, 0.0f, 0.0f, 1.0f);

	glTranslatef(0.0f, fDeltaDistanciaInst1, 0.0f);

	glGetFloatv(GL_MODELVIEW_MATRIX, m);

	//Coordenada 1
	pos[0] = objTrianguloTemp1.getVertice1()->getX();
	pos[1] = objTrianguloTemp1.getVertice1()->getY();
	pos[2] = objTrianguloTemp1.getVertice1()->getZ();
	pos[3] = 1.0f;
	VMatMult(m,pos);
	objSimulacion.getTrianguloTemp1().getVertice1()->setX(pos[0]);
	objSimulacion.getTrianguloTemp1().getVertice1()->setY(pos[1]);
	objSimulacion.getTrianguloTemp1().getVertice1()->setZ(pos[2]);

	//Coordenada 2
	pos[0] = objTrianguloTemp1.getVertice2()->getX();
	pos[1] = objTrianguloTemp1.getVertice2()->getY();
	pos[2] = objTrianguloTemp1.getVertice2()->getZ();
	pos[3] = 1.0f;
	VMatMult(m,pos);
	objSimulacion.getTrianguloTemp1().getVertice2()->setX(pos[0]);
	objSimulacion.getTrianguloTemp1().getVertice2()->setY(pos[1]);
	objSimulacion.getTrianguloTemp1().getVertice2()->setZ(pos[2]);

	//Coordenada 3
	pos[0] = objTrianguloTemp1.getVertice3()->getX();
	pos[1] = objTrianguloTemp1.getVertice3()->getY();
	pos[2] = objTrianguloTemp1.getVertice3()->getZ();
	pos[3] = 1.0f;
	VMatMult(m,pos);
	objSimulacion.getTrianguloTemp1().getVertice3()->setX(pos[0]);
	objSimulacion.getTrianguloTemp1().getVertice3()->setY(pos[1]);
	objSimulacion.getTrianguloTemp1().getVertice3()->setZ(pos[2]);

	//TRANSFORMANDO EL TRIANGULO DE COLISION DEL INSTRUMENTO 2
	glLoadIdentity();

	if(enmSesion1 == TRANSPORTAR_CUBOS || enmSesion1 == ORDENAR_CUBOS) 
	{
		glTranslatef(fMainX+xtrasl, fMainY+ytrasl, fMainZ+ztrasl);
		glRotatef(xrot+102.0f, 1.0f, 0.0f, 0.0f);
		glRotatef(yrot, 0.0f, 1.0f, 0.0f);
		glRotatef(zrot, 0.0f, 0.0f, 1.0f);
	}

	//Aplica las traslaciones	
	glTranslatef(fX2, fY2, fZ2);

	//Aplica las rotaciones
	glRotatef(-ryPolInts2, 1.0f, 0.0f, 0.0f);
	glRotatef(rzPolInts2, 0.0f, 1.0f, 0.0f);
	glRotatef(rxPolInts2, 0.0f, 0.0f, 1.0f);

	glTranslatef(0.0f, fDeltaDistanciaInst2, 0.0f);

	glGetFloatv(GL_MODELVIEW_MATRIX, m);

	//Coordenada 1
	pos[0] = objTrianguloTemp2.getVertice1()->getX();
	pos[1] = objTrianguloTemp2.getVertice1()->getY();
	pos[2] = objTrianguloTemp2.getVertice1()->getZ();
	pos[3] = 1.0f;
	VMatMult(m,pos);
	objSimulacion.getTrianguloTemp2().getVertice1()->setX(pos[0]);
	objSimulacion.getTrianguloTemp2().getVertice1()->setY(pos[1]);
	objSimulacion.getTrianguloTemp2().getVertice1()->setZ(pos[2]);

	//Coordenada 2
	pos[0] = objTrianguloTemp2.getVertice2()->getX();
	pos[1] = objTrianguloTemp2.getVertice2()->getY();
	pos[2] = objTrianguloTemp2.getVertice2()->getZ();
	pos[3] = 1.0f;
	VMatMult(m,pos);
	objSimulacion.getTrianguloTemp2().getVertice2()->setX(pos[0]);
	objSimulacion.getTrianguloTemp2().getVertice2()->setY(pos[1]);
	objSimulacion.getTrianguloTemp2().getVertice2()->setZ(pos[2]);

	//Coordenada 3
	pos[0] = objTrianguloTemp2.getVertice3()->getX();
	pos[1] = objTrianguloTemp2.getVertice3()->getY();
	pos[2] = objTrianguloTemp2.getVertice3()->getZ();
	pos[3] = 1.0f;
	VMatMult(m,pos);
	objSimulacion.getTrianguloTemp2().getVertice3()->setX(pos[0]);
	objSimulacion.getTrianguloTemp2().getVertice3()->setY(pos[1]);
	objSimulacion.getTrianguloTemp2().getVertice3()->setZ(pos[2]);

	//VISUALIZANDO TRIANGULO EN EL INSTRUMENTO 1 PARA LA COLISION
	glLoadIdentity();

	if(enmSesion1 == SIMULACION_HIGADO)
	{
		glTranslatef(fMainX+xtrasl, fMainY+ytrasl, fMainZ+ztrasl);
		glRotatef(xrot+102.0f, 1.0f, 0.0f, 0.0f);
		glRotatef(yrot, 0.0f, 1.0f, 0.0f);
		glRotatef(zrot, 0.0f, 0.0f, 1.0f);
	}

	glColor3f(1.0f, 0.0f, 1.0f);

	glBegin(GL_LINE_LOOP);
	glVertex3f(objSimulacion.getTrianguloTemp1().getVertice1()->getX(),
	objSimulacion.getTrianguloTemp1().getVertice1()->getY(),
	objSimulacion.getTrianguloTemp1().getVertice1()->getZ());
	glVertex3f(objSimulacion.getTrianguloTemp1().getVertice2()->getX(),
	objSimulacion.getTrianguloTemp1().getVertice2()->getY(),
	objSimulacion.getTrianguloTemp1().getVertice2()->getZ());
	glVertex3f(objSimulacion.getTrianguloTemp1().getVertice3()->getX(),
	objSimulacion.getTrianguloTemp1().getVertice3()->getY(),
	objSimulacion.getTrianguloTemp1().getVertice3()->getZ());
	glEnd();

	//VISUALIZANDO TRINAGULO EN EL INSTRUMENTO 2 PARA LA COLISION
	glLoadIdentity();

	if(enmSesion1 == SIMULACION_HIGADO)
	{
		glTranslatef(fMainX+xtrasl, fMainY+ytrasl, fMainZ+ztrasl);
		glRotatef(xrot+102.0f, 1.0f, 0.0f, 0.0f);
		glRotatef(yrot, 0.0f, 1.0f, 0.0f);
		glRotatef(zrot, 0.0f, 0.0f, 1.0f);
	}

	glColor3f(1.0f, 0.0f, 1.0f);

	glBegin(GL_LINE_LOOP);
	glVertex3f(objSimulacion.getTrianguloTemp2().getVertice1()->getX(),
	objSimulacion.getTrianguloTemp2().getVertice1()->getY(),
	objSimulacion.getTrianguloTemp2().getVertice1()->getZ());
	glVertex3f(objSimulacion.getTrianguloTemp2().getVertice2()->getX(),
	objSimulacion.getTrianguloTemp2().getVertice2()->getY(),
	objSimulacion.getTrianguloTemp2().getVertice2()->getZ());
	glVertex3f(objSimulacion.getTrianguloTemp2().getVertice3()->getX(),
	objSimulacion.getTrianguloTemp2().getVertice3()->getY(),
	objSimulacion.getTrianguloTemp2().getVertice3()->getZ());
	glEnd();

}

void Sesion::DrawSphereTriang(float fMainX, float fMainY, float fMainZ, float fX1,
							  float fY1, float fZ1, float fX2, float fY2, float fZ2)
{
	//DIBUJANDO ESFERA 1
	glLoadIdentity();

	/*glTranslatef(fMainX+xtrasl, fMainY+ytrasl, fMainZ+ztrasl);
	glRotatef(xrot+102.0f, 1.0f, 0.0f, 0.0f);
	glRotatef(yrot, 0.0f, 1.0f, 0.0f);
	glRotatef(zrot, 0.0f, 0.0f, 1.0f);*/

	glTranslatef(objSimulacion.getInstrumentoQco1().get_Esfera().get_Centro().getX(),
		objSimulacion.getInstrumentoQco1().get_Esfera().get_Centro().getY(),
		objSimulacion.getInstrumentoQco1().get_Esfera().get_Centro().getZ());

	glutWireSphere(objSimulacion.getInstrumentoQco1().get_Esfera().get_Radio(),15,15);

	

	//DIBUJANDO ESFERA 2
	glLoadIdentity();

	/*glTranslatef(fMainX+xtrasl, fMainY+ytrasl, fMainZ+ztrasl);
	glRotatef(xrot+102.0f, 1.0f, 0.0f, 0.0f);
	glRotatef(yrot, 0.0f, 1.0f, 0.0f);
	glRotatef(zrot, 0.0f, 0.0f, 1.0f);*/

	glTranslatef(objSimulacion.getInstrumentoQco2().get_Esfera().get_Centro().getX(),
		objSimulacion.getInstrumentoQco2().get_Esfera().get_Centro().getY(),
		objSimulacion.getInstrumentoQco2().get_Esfera().get_Centro().getZ());

	glutWireSphere(objSimulacion.getInstrumentoQco1().get_Esfera().get_Radio(),15,15);

}
	
void Sesion::AuxTriangCubo(float fMainX, float fMainY, float fMainZ, float fX1,
						   float fY1, float fZ1, float fX2, float fY2, float fZ2)
{
	GLfloat m[16];
	GLfloat pos[4];

	for(int i=0;i<intNumeroCubos;i++)
	{
		//POSICION AUXILIAR PARA EL DESPLAZAMIENTO DEL CUBO CON RESPECTO AL INSTRUMENTO 1
		glLoadIdentity();

		//Aplica las traslaciones	
		glTranslatef(fX1, fY1, fZ1);		//400.0	  250.0   -50.0

		//Aplica las rotaciones
		glRotatef(-ryPolInts1, 1.0f, 0.0f, 0.0f);
		glRotatef(rzPolInts1, 0.0f, 1.0f, 0.0f);
		glRotatef(rxPolInts1, 0.0f, 0.0f, 1.0f);

		glTranslatef(0.0f, fDeltaDistanciaInst1, 0.0f);

		glGetFloatv(GL_MODELVIEW_MATRIX, m);

		pos[0] = objTrianguloTemp1.getVertice1()->getX();
		pos[1] = objTrianguloTemp1.getVertice1()->getY();
		pos[2] = objTrianguloTemp1.getVertice1()->getZ();
		pos[3] = 1.0f;
		VMatMult(m,pos);

		fPosXCuboAux1[i] = pos[0];
		fPosYCuboAux1[i] = pos[1];
		fPosZCuboAux1[i] = pos[2];

		//POSICION AUXILIAR PARA EL DESPLAZAMIENTO DEL CUBO CON RESPECTO AL INSTRUMENTO 2
		glLoadIdentity();

		//Aplica las traslaciones	
		glTranslatef(fX2, fY2, fZ2);		//400.0	  250.0   -50.0

		//Aplica las rotaciones
		glRotatef(-ryPolInts2, 1.0f, 0.0f, 0.0f);
		glRotatef(rzPolInts2, 0.0f, 1.0f, 0.0f);
		glRotatef(rxPolInts2, 0.0f, 0.0f, 1.0f);

		glTranslatef(0.0f, fDeltaDistanciaInst2, 0.0f);

		glGetFloatv(GL_MODELVIEW_MATRIX, m);

		pos[0] = objTrianguloTemp2.getVertice1()->getX();
		pos[1] = objTrianguloTemp2.getVertice1()->getY();
		pos[2] = objTrianguloTemp2.getVertice1()->getZ();
		pos[3] = 1.0f;
		VMatMult(m,pos);

		fPosXCuboAux2[i] = pos[0];
		fPosYCuboAux2[i] = pos[1];
		fPosZCuboAux2[i] = pos[2];
	}
}

void Sesion::DrawGround()
{
	float MatAmbGround[4] = {0.1f,0.1f,0.1f,1.0f};
	float MatDifGround[4] = {1.0f,0.0f,0.0f,1.0f};
	float MatSpcGround[4] = {1.0f,1.0f,1.0f,1.0f};
	float MatShnGround = 100.0f;

	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, MatAmbGround);			// Configura material ambiental
	glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MatDifGround);			// Configura material difuso
	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, MatSpcGround);		// Configura material especular
	glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, MatShnGround);
	
	glLoadIdentity();
	
	glEnable(GL_LIGHT1);
	glEnable(GL_LIGHTING);

	//Asignando el punto de origen
	glTranslatef(xtrasl, ytrasl, -790.0f+ztrasl);
	glRotatef(xrot+102.0f, 1.0f, 0.0f, 0.0f);
	glRotatef(yrot, 0.0f, 1.0f, 0.0f);
	glRotatef(zrot, 0.0f, 0.0f, 1.0f);

	if(objVisualizacion.get_TipoVisualizacion() == DIBUJAR_LINEAS || 
		objVisualizacion.get_TipoVisualizacion() == DIBUJAR_PUNTOS)
	{
		glBegin(GL_LINE_LOOP);
		glVertex3f(-300.0f,-300.0f,100.0f);
		glVertex3f(-300.0f,300.0f,100.0f);
		glVertex3f(300.0f,-300.0f,100.0f);
		glEnd();

		glBegin(GL_LINE_LOOP);
		glVertex3f(300.0f,300.0f,100.0f);
		glVertex3f(300.0f,-300.0f,100.0f);
		glVertex3f(-300.0f,300.0f,100.0f);
		glEnd();

	}
	else if(objVisualizacion.get_TipoVisualizacion() == DIBUJAR_CONTORNO_SMOOTH || 
		objVisualizacion.get_TipoVisualizacion() == DIBUJAR_CONTORNO_FLAT)
	{
		glBegin(GL_TRIANGLES);
		glNormal3f(0.0f,0.0f,-1.0f);
		glVertex3f(-300.0f,-300.0f,100.0f);
		glVertex3f(-300.0f,300.0f,100.0f);
		glVertex3f(300.0f,-300.0f,100.0f);
		glEnd();

		glBegin(GL_TRIANGLES);
		glNormal3f(0.0f,0.0f,-1.0f);
		glVertex3f(300.0f,300.0f,100.0f);
		glVertex3f(300.0f,-300.0f,100.0f);
		glVertex3f(-300.0f,300.0f,100.0f);
		glEnd();
	}

	if(enmSesion1 == TRANSPORTAR_CUBOS)
	{
		float MatAmbPtoClave[4] = {0.1f,0.1f,0.1f,1.0f};
		float MatDifPtoClave[4] = {0.25f,0.5f,0.5f,1.0f};
		float MatSpcPtoClave[4] = {1.0f,1.0f,1.0f,1.0f};
		float MatShnPtoClave = 100.0f;

		glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, MatAmbPtoClave);			// Configura material ambiental
		glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MatDifPtoClave);			// Configura material difuso
		glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, MatSpcPtoClave);		// Configura material especular
		glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, MatShnPtoClave);

		if(objVisualizacion.get_TipoVisualizacion() == DIBUJAR_LINEAS || 
		objVisualizacion.get_TipoVisualizacion() == DIBUJAR_PUNTOS)
		{
			glBegin(GL_LINE_LOOP);
			glVertex3f(-250.0f,-250.0f,99.0f);
			glVertex3f(-250.0f,0.0f,99.0f);
			glVertex3f(0.0f,0.0f,99.0f);
			glEnd();

			glBegin(GL_LINE_LOOP);
			glVertex3f(0.0f,0.0f,99.0f);
			glVertex3f(0.0f,-250.0f,99.0f);
			glVertex3f(-250.0f,-250.0f,99.0f);
			glEnd();

		}
		else if(objVisualizacion.get_TipoVisualizacion() == DIBUJAR_CONTORNO_SMOOTH || 
			objVisualizacion.get_TipoVisualizacion() == DIBUJAR_CONTORNO_FLAT)
		{
			glBegin(GL_TRIANGLES);
			glNormal3f(0.0f,0.0f,-1.0f);
			glVertex3f(-250.0f,-250.0f,99.0f);
			glVertex3f(-250.0f,0.0f,99.0f);
			glVertex3f(0.0f,0.0f,99.0f);
			glEnd();

			glBegin(GL_TRIANGLES);
			glNormal3f(0.0f,0.0f,-1.0f);
			glVertex3f(0.0f,0.0f,99.0f);
			glVertex3f(0.0f,-250.0f,99.0f);
			glVertex3f(-250.0f,-250.0f,99.0f);
			glEnd();	
		}
	}
	else if(enmSesion1 == ORDENAR_CUBOS)
	{
		//Left Ground
		float temp1[4] = {(float)vMatAmbCubo[2].getValor(1),(float)vMatAmbCubo[2].getValor(2),
								(float)vMatAmbCubo[2].getValor(3),(float)vMatAmbCubo[2].getValor(4)};
		float temp2[4] = {(float)vMatDifCubo[2].getValor(1),(float)vMatDifCubo[2].getValor(2),
								(float)vMatDifCubo[2].getValor(3),(float)vMatDifCubo[2].getValor(4)};
		float temp3[4] = {(float)vMatSpcCubo[2].getValor(1),(float)vMatSpcCubo[2].getValor(2),
								(float)vMatSpcCubo[2].getValor(3),(float)vMatSpcCubo[2].getValor(4)};
		

		glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, temp1);			// Configura material ambiental
		glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, temp2);			// Configura material difuso
		glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, temp3);		// Configura material especular
		glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, vMatShnCubo[2]);

		if(objVisualizacion.get_TipoVisualizacion() == DIBUJAR_LINEAS || 
		objVisualizacion.get_TipoVisualizacion() == DIBUJAR_PUNTOS)
		{
			glBegin(GL_LINE_LOOP);
			glVertex3f(-300.0f,-200.0f,99.0f);
			glVertex3f(-300.0f,0.0f,99.0f);
			glVertex3f(-100.0f,0.0f,99.0f);
			glEnd();

			glBegin(GL_LINE_LOOP);
			glVertex3f(-100.0f,0.0f,99.0f);
			glVertex3f(-100.0f,-200.0f,99.0f);
			glVertex3f(-300.0f,-200.0f,99.0f);
			glEnd();

		}
		else if(objVisualizacion.get_TipoVisualizacion() == DIBUJAR_CONTORNO_SMOOTH || 
			objVisualizacion.get_TipoVisualizacion() == DIBUJAR_CONTORNO_FLAT)
		{
			glBegin(GL_TRIANGLES);
			glNormal3f(0.0f,0.0f,-1.0f);
			glVertex3f(-300.0f,-200.0f,99.0f);
			glVertex3f(-300.0f,0.0f,99.0f);
			glVertex3f(-100.0f,0.0f,99.0f);
			glEnd();

			glBegin(GL_TRIANGLES);
			glNormal3f(0.0f,0.0f,-1.0f);
			glVertex3f(-100.0f,0.0f,99.0f);
			glVertex3f(-100.0f,-200.0f,99.0f);
			glVertex3f(-300.0f,-200.0f,99.0f);
			glEnd();
		}

		//Right Ground
		float temp4[4] = {(float)vMatAmbCubo[0].getValor(1),(float)vMatAmbCubo[0].getValor(2),
								(float)vMatAmbCubo[0].getValor(3),(float)vMatAmbCubo[0].getValor(4)};
		float temp5[4] = {(float)vMatDifCubo[0].getValor(1),(float)vMatDifCubo[0].getValor(2),
								(float)vMatDifCubo[0].getValor(3),(float)vMatDifCubo[0].getValor(4)};
		float temp6[4] = {(float)vMatSpcCubo[0].getValor(1),(float)vMatSpcCubo[0].getValor(2),
								(float)vMatSpcCubo[0].getValor(3),(float)vMatSpcCubo[0].getValor(4)};
		

		glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, temp4);			// Configura material ambiental
		glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, temp5);			// Configura material difuso
		glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, temp6);		// Configura material especular
		glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, vMatShnCubo[0]);

		if(objVisualizacion.get_TipoVisualizacion() == DIBUJAR_LINEAS || 
		objVisualizacion.get_TipoVisualizacion() == DIBUJAR_PUNTOS)
		{
			glBegin(GL_LINE_LOOP);
			glVertex3f(-100.0f,-200.0f,99.0f);
			glVertex3f(-100.0f,0.0f,99.0f);
			glVertex3f(100.0f,0.0f,99.0f);
			glEnd();

			glBegin(GL_LINE_LOOP);
			glVertex3f(100.0f,0.0f,99.0f);
			glVertex3f(100.0f,-200.0f,99.0f);
			glVertex3f(-100.0f,-200.0f,99.0f);
			glEnd();

		}
		else if(objVisualizacion.get_TipoVisualizacion() == DIBUJAR_CONTORNO_SMOOTH || 
			objVisualizacion.get_TipoVisualizacion() == DIBUJAR_CONTORNO_FLAT)
		{
			glBegin(GL_TRIANGLES);
			glNormal3f(0.0f,0.0f,-1.0f);
			glVertex3f(-100.0f,-200.0f,99.0f);
			glVertex3f(-100.0f,0.0f,99.0f);
			glVertex3f(100.0f,0.0f,99.0f);
			glEnd();

			glBegin(GL_TRIANGLES);
			glNormal3f(0.0f,0.0f,-1.0f);
			glVertex3f(100.0f,0.0f,99.0f);
			glVertex3f(100.0f,-200.0f,99.0f);
			glVertex3f(-100.0f,-200.0f,99.0f);
			glEnd();
		}

		//Center Ground
		float temp7[4] = {(float)vMatAmbCubo[1].getValor(1),(float)vMatAmbCubo[1].getValor(2),
								(float)vMatAmbCubo[1].getValor(3),(float)vMatAmbCubo[1].getValor(4)};
		float temp8[4] = {(float)vMatDifCubo[1].getValor(1),(float)vMatDifCubo[1].getValor(2),
								(float)vMatDifCubo[1].getValor(3),(float)vMatDifCubo[1].getValor(4)};
		float temp9[4] = {(float)vMatSpcCubo[1].getValor(1),(float)vMatSpcCubo[1].getValor(2),
								(float)vMatSpcCubo[1].getValor(3),(float)vMatSpcCubo[1].getValor(4)};
		

		glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, temp7);			// Configura material ambiental
		glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, temp8);			// Configura material difuso
		glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, temp9);		// Configura material especular
		glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, vMatShnCubo[1]);

		if(objVisualizacion.get_TipoVisualizacion() == DIBUJAR_LINEAS || 
		objVisualizacion.get_TipoVisualizacion() == DIBUJAR_PUNTOS)
		{
			glBegin(GL_LINE_LOOP);
			glVertex3f(100.0f,-200.0f,99.0f);
			glVertex3f(100.0f,0.0f,99.0f);
			glVertex3f(300.0f,0.0f,99.0f);
			glEnd();

			glBegin(GL_LINE_LOOP);
			glVertex3f(300.0f,0.0f,99.0f);
			glVertex3f(300.0f,-200.0f,99.0f);
			glVertex3f(100.0f,-200.0f,99.0f);
			glEnd();

		}
		else if(objVisualizacion.get_TipoVisualizacion() == DIBUJAR_CONTORNO_SMOOTH || 
			objVisualizacion.get_TipoVisualizacion() == DIBUJAR_CONTORNO_FLAT)
		{
			glBegin(GL_TRIANGLES);
			glNormal3f(0.0f,0.0f,-1.0f);
			glVertex3f(100.0f,-200.0f,99.0f);
			glVertex3f(100.0f,0.0f,99.0f);
			glVertex3f(300.0f,0.0f,99.0f);
			glEnd();

			glBegin(GL_TRIANGLES);
			glNormal3f(0.0f,0.0f,-1.0f);
			glVertex3f(300.0f,0.0f,99.0f);
			glVertex3f(300.0f,-200.0f,99.0f);
			glVertex3f(100.0f,-200.0f,99.0f);
			glEnd();	
		}
	}
}

void Sesion::IniciarEvaluacion()
{
	if(enmSesion1 == TRANSPORTAR_CUBOS || enmSesion1 == ORDENAR_CUBOS)
	{
		objEvaluacion.setNumeroCubos(intNumeroCubos);
		objEvaluacion.IniciarEvaluacion();
	}
}

void Sesion::FinalizarEvaluacion()
{
	if(enmSesion1 == TRANSPORTAR_CUBOS)
	{
		//Creando vertice para la ubicacion objetivo
		Vertice objVerticeTempEva;

		objVerticeTempEva.setX(-125.0f);
		objVerticeTempEva.setY(-125.0f);
		objVerticeTempEva.setZ(99.0f);

		objEvaluacion.setUbicacionObjetivo(objVerticeTempEva);
	}
	else if(enmSesion1 == ORDENAR_CUBOS)
	{
		//Creando los vertices de ubicacion de los objetivos
		Vertice objVerticeTemp1;

		objVerticeTemp1.setX(-200.0f);
		objVerticeTemp1.setY(-100.0f);
		objVerticeTemp1.setZ(99.0f);

		Vertice objVerticeTemp2;

		objVerticeTemp2.setX(0.0f);
		objVerticeTemp2.setY(-100.0f);
		objVerticeTemp2.setZ(99.0f);

		Vertice objVerticeTemp3;

		objVerticeTemp3.setX(200.0f);
		objVerticeTemp3.setY(-100.0f);
		objVerticeTemp3.setZ(99.0f);

		vector<Vertice> objVerticesTemp;
		objVerticesTemp.push_back(objVerticeTemp2);
		objVerticesTemp.push_back(objVerticeTemp3);
		objVerticesTemp.push_back(objVerticeTemp1);

		objEvaluacion.setUbicacionObjetivos(objVerticesTemp);
	}

	//Creando vector de Vertices de la ubicacion de los cubos
	vector<Vertice> vVerticesTempEva;

	for(int i=0;i<intNumeroCubos;i++)
	{
		Vertice objVerticeTemp;

		objVerticeTemp.setX(fPosXCubo[i]);
		objVerticeTemp.setY(fPosYCubo[i]);
		objVerticeTemp.setZ(fPosZCubo[i]);

		vVerticesTempEva.push_back(objVerticeTemp);

		cout << fPosXCubo[i] << "  " << fPosYCubo[i] << "  " << fPosZCubo[i] << endl;
	}

	objEvaluacion.setTipoSesion(enmSesion1);
	objEvaluacion.setUbicacionObjetos(vVerticesTempEva);
	objEvaluacion.FinalizarEvaluacion();
}



